home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Texteditors / XDME / include / hrexx.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-27  |  10.9 KB  |  274 lines
  1. #include <dos/dos.h>
  2. #include <exec/types.h>
  3. #ifndef Prototype
  4. #define Prototype extern
  5. #endif
  6.  
  7. /*********************************************************************/
  8. /*      Die Funktion OpenRexx öffnet, wenn möglich einen RexxPort.   */
  9. /*********************************************************************/
  10.  
  11. /*
  12.  * OpenRexx     initialisiert die ARexxumgebung. Dafür wird, wenn benötigt
  13.  *      Arexxlibrary geöffnet, ein Port initialisiert, die Defaultextension
  14.  *      festgelegt und die std Ein- und Ausgabekanäle bestimmt.
  15.  *
  16.  * --> name     Name des ARexxPorts den unser Programm bekommt.
  17.  *              Existiert ein solcher Port bereits wird der FehlerCode
  18.  *              ERROR_PORT_ALLREADY_EXISTS zurückgegeben
  19.  * --> ext      Zeiger auf die extension, wenn NULL dan .REXX
  20.  * --> do_res   Zeiger auf die Funktion zum Message handling.
  21.  *              Wird aufgerufen wenn während der Arbeit ein RexxMsg anfällt
  22.  * --> in,out   std input/output handle
  23.  * <-- RESLUT   SigBit   Success FALSE wenn nicht geöffnet
  24.  */
  25.  
  26.  
  27. /******************************************************************/
  28. /*      beantwortet alle anstehenden Messages, mit RXRERRORIMGONE  */
  29. /*      wartet auf alle noch zu beantwortenden Messages           */
  30. /*      schließt den Port                                         */
  31. /*      schließt die ArexxSysBase                                 */
  32. /******************************************************************/
  33.  
  34.  
  35. /********************************************************************/
  36. /*      Mit dieser Funktion kann man den letzten aufegetreten       */
  37. /*      FehlerCode festellen                                        */
  38. /********************************************************************/
  39.  
  40.  
  41. /****************************************************************/
  42. /*      BuildRexxMsg erstellt eine ARexx Message und füllt      */
  43. /*      die Argument slots mit den Parametern                   */
  44. /****************************************************************/
  45. /*
  46.  *      Aufruf erfolgt: BuildRexxMsg(com,flags,arg0,arg1,arg2,...,argn)
  47.  *      Es dürfen maximal 15 Argumente übergeben werden. Weitere Argumente
  48.  *      werden ignoriert. Will man nur 3 Argumente übergeben (arg1-arg3)
  49.  *      übergibt man als letztes Argument (arg4) NULL
  50.  *      Die Funktion gibt einen Zeiger auf die erstellte Message zurück,
  51.  *      im Fehlerfalle NULL.
  52.  */
  53.    /*
  54.     *      com ist der Name des aufzurufenden Kommandos.
  55.     *      Alles Strings (com & args) sind normale mit NULL abgeschloßene
  56.     *      C-Strings.
  57.     */
  58.    /*
  59.     *      action dieses Flag wir direkt im Command (action) Field
  60.     *      der RexxMessage struktur eingefügt
  61.     */
  62.    /*
  63.     *      first_arg is ein Zeiger auf das erste Argument (aufruf der
  64.     *      Funktion s.o.
  65.     *      Aufgrund der internen Handhabung wird nur der erste Parameter im
  66.     *      Funktionskopf angenommen.
  67.     *      Die Argumente sind normale 0-terminierte C-Strings
  68.     */
  69.    /*
  70.     *      Weitere Argumente:
  71.     */
  72.  
  73.  
  74. /*****************************************************************/
  75. /*      Dies Funktion gibt den Speicher einer RexxMessage frei.  */
  76. /*      Also die Argumente, einen ggf vorhandenen ReturnWert     */
  77. /*      und die Message selbst. Aus diesem Grund müßen Felder    */
  78. /*      (Argumente und Return Code, wenn sie außerhalb der       */
  79. /*      Funktion freigegeben worden sind auf NULL gesetzt werden */
  80. /*****************************************************************/
  81.    /* Zeiger auf die zu löschende RexxMessage */
  82.    /*
  83.     *      gibt TRUE für Erfolg zurück
  84.     */
  85.  
  86.  
  87. /****************************************************************/
  88. /*      PutRexxMsg schickt eine Message an den genannten Port   */
  89. /*      un übernimmt die Buchführung über fehlende Antworten    */
  90. /****************************************************************/
  91.    /*
  92.     *      Port ist der Name des Ziel Ports. Der Name ist NULL beendeter
  93.     *      String. Achtung !! kein PortPointer.
  94.     *      Ist port NULL so wird die Message an den RexxHostPort geschickt.
  95.     *      Da man einen eigenen Namen angeben kann, ist möglich, Messages
  96.     *      direkt an andere Rexxfähige Programme zu senden.
  97.     */
  98.    /*
  99.     *      rmsg    ist ein Zeiger auf gültige, vollstänig initialisierte
  100.     *      RexxMessage-Struktur.
  101.     */
  102.  
  103.  
  104. /****************************************************************/
  105. /*      GetRexxMsg funktioniert GetMsg des Betriebsystems,      */
  106. /*      nur das Über die Messages Buchgeführt wird              */
  107. /****************************************************************/
  108. /*
  109.  *      Die Funktion gibt einen Zeiger auf die Message oder NULL
  110.  *      zurück.
  111.  *      Ist NULL ein Fehler, so kann das mit LastRexxError festgestellt
  112.  *      werden. Sonst bedeutet es einfach, das keine Msg am Port
  113.  *      wartet.
  114.  */
  115.  
  116.  
  117. /****************************************************************/
  118. /*      FetchRexxMsg wartet bis eine Message an unserm          */
  119. /*      Port ankommt und gibt diese zurück.                     */
  120. /****************************************************************/
  121. /*
  122.  *      Die Funktion kehrt mit einem Zeiger auf die vom
  123.  *      Port geholte Message zurück.
  124.  */
  125.  
  126.  
  127. /****************************************************************/
  128. /*      ReplyRexxMsg    setzt den ArexxErrorCode, füllt den     */
  129. /*      Returnwert_slot und beantwortet die Message.            */
  130. /*      sollte es eine NonReply Message sein, so wird sie       */
  131. /*      einfach gelöscht                                        */
  132. /****************************************************************/
  133. /*
  134.  *      Im falle eines Fehlers kehrt die Funktion mit FALSE zurück.
  135.  *      Nähere Information kann man LastRexxError holen
  136.  */
  137.    /*
  138.     *      rmsg    ist ein Zeiger auf die zu beantwortende Message
  139.     */
  140.    /*
  141.     *      rexx_error ist ein Langwort, das den ArexxErrorCode enthält.
  142.     *      Der Code wird in das Result1 Fe ld der Message eingetragen.
  143.     */
  144.    /*
  145.     *      return_string ist ein String, der als Return wert and den
  146.     *      Caller zurückgegeben wird. ReplyRexxMsg generiert aus diesem
  147.     *      C-String ein ArexxArgument un füllt dies in das Result2
  148.     *      Feld ein.
  149.     *      Ist rexx_error != 0, also ein Fehler aufgetreten, so wird der
  150.     *      String ignoriert und das Feld auf NULL gesetz. Soll kein
  151.     *      Returnwert zurückgegeben werden ist ein NULL-Pointer zu übergeben.
  152.     */
  153.  
  154.  
  155. /**********************************************************************/
  156. /*      SyncRexxCommand sendet ein Kommando, und wartet bis das       */
  157. /*      Kommando abgearbeitet ist. Sollten in der Zwischenzeit        */
  158. /*      Kommandos an unser Port gehen, wird die Funktion              */
  159. /*      process_message mit dem Zeiger auf die Message aufgerufen.    */
  160. /*      So ist es möglich, währen eines SyncAufrufes Kommandos zu     */
  161. /*      Empfangen. SyncRexxCommand unterstützt einen returncode.      */
  162. /*      Dazu muß eine StringBuffer und die Größe des Buffer über-     */
  163. /*      geben werden .                                                */
  164. /*      Der aufruf erfolgt:                                           */
  165. /*      SyncRexxCommand(port,com,result,result_len,arg1,arg2,...,argn)*/
  166. /*      Werden nicht alle Argumente genutzt, muß das letzte Argument  */
  167. /*      NULL sein. Mehr als 15 Argumente werden ignoriert.            */
  168. /**********************************************************************/
  169. /*
  170.  *      Die Funktion kehrt mit dem ArexxErrorCode oder dem Internen
  171.  *      errorcode zurück.
  172.  *      0 für eine erfolgreiche aktion.
  173.  *      Kommt es zu einem RexxFehler, so wird der ResultString gelöscht.
  174.  */
  175.    /*
  176.     *      port ist der Name des Ports an den das Kommando gesendet werden soll.
  177.     *      wird als PortName 0 angegeben, so wird das Kommando an den Rexx-
  178.     *      Host geschickt.
  179.     */
  180.    /*
  181.     *      Com ist der String der den KommandoNamen enthält
  182.     */
  183.    /*
  184.     *      result ist ein Pointer auf den StringBuffer in den der
  185.     *      ResultString des Kommandos kopiert werden soll. Ist result == NULL
  186.     *      oder result_len == NULL so wird die Fukntion als Kommando
  187.     *      ohne ReturnWert betrachtet, und die Flags in der RexxMsg
  188.     *      entsprechend gesetzt.
  189.     */
  190.    /*
  191.     *      first_arg Zeiger auf den ersten Argument String. Der aufruf Syntax
  192.     *      ist oben beschrieben, und Funktioniert wie bei BuildRexxMessage.
  193.     */
  194.    /*
  195.     *   weitere args
  196.     */
  197.  
  198.  
  199. /****************************************************************/
  200. /*      RexxMessageHandler sucht die FunktionsListe durch, und  */
  201. /*      ruft, falls es das Kommando gibt, die dazugehörige      */
  202. /*      Funktion auf. Sollte das Kommando nicht existieren      */
  203. /*      wird der ARexxFehlerCode Label NotFound zurückgegeben.  */
  204. /****************************************************************/
  205. /*
  206.  * RexxMessageHandler ruft bei ankommenden Messages die in der
  207.  * Funktionliste übergebenen Kommandos auf.
  208.  *
  209.  * --> rmsg     Zeiger auf die RexxMessage, die bearbeitet werden soll
  210.  */
  211.  
  212.  
  213. /****************************************************************/
  214. /*      ChangeProcessMessage    ändert den Zeiger der process_  */
  215. /*      message funktion.                                       */
  216. /****************************************************************/
  217. /*
  218.  * ChangeProcessMessage ändert die Funktion für das InterneMessagehandling
  219.  *
  220.  * --> new_function     Zeiger auf die neue Funktion, bei -1 wird
  221.  *              der HRexx interne Handler verwendet
  222.  * <-- RESULT   Pointer auf alten hndler
  223.  */
  224.  
  225. /****************************************************************/
  226. /*      SetRexxCommandTable  ändert die interne Kommandotabelle */
  227. /****************************************************************/
  228.    /*
  229.     *      Zeiger auf eine vom Benutzer definierte Kommando Tabelle
  230.     */
  231.    /*
  232.     *      gibt den Zeiger auf die alte Funktiontabelle zurück.
  233.     */
  234.  
  235.  
  236. /* Internal ErrorCodes */
  237. #define  RERROR_AREXX_ALLREADY_OPEN      -1
  238. #define  RERROR_OUT_OF_MEMORY            -2
  239. #define  RERROR_NO_AREXX                 -3
  240. #define  RERROR_PORT_ALLREADY_EXISTS     -4
  241. #define  RERROR_INVALID_PORT_NAME        -5
  242. #define  RERROR_NO_PORT                  -6
  243. #define  RERROR_AREXX_NOT_OPEN           -7
  244. #define  RERROR_INVALID_COMMAND_NAME     -8
  245. #define  RERROR_UNKNOWN_DESTINATION_PORT -9
  246. #define  RERROR_NO_MSG                   -10
  247. #define  RERROR_STRING_TOO_LONG          -11
  248. #define  RERROR_NO_COMMAND_TABLE         -12
  249.  
  250. struct  RexxCommand
  251. {
  252.    char *Name;
  253.    long  (*Function)(char * _s,struct RexxMsg *rmsg);
  254. };
  255.  
  256. /*************************************************************/
  257. /*  ModifyRepCount  ändert Anzahl fehlender Messages         */
  258. /*************************************************************/
  259. /*
  260.  ModifyRepCount
  261.         ändert den Counter mit den fehlenden Messages um den in
  262.         delta angegebenen Betrag.
  263.         Der alte wert von RepCount wird zurückgegeben
  264. */
  265.  
  266. /*
  267.  AttempCloseRexx
  268.         probiert den ARexxPort zu schliessen (funktioniert nur, wenn
  269.         OutstandingReplies==0 ist), kann das RexxSystem geschlossen
  270.         werden kommt TRUE zurück, sonst False
  271. */
  272.  
  273.  
  274.